A computer system can typically issue write requests which specify that particular data be stored on a particular storage medium at a particular location (e.g., in a memory location in a computer RAM), and read requests which specify that the data currently stored at a particular location on a particular storage device be retrieved and returned. It is often the case that a storage medium can only be written to by a single computer system. When a computer system retrieves data from a storage medium location to which only it has the ability to write, the retrieved data should be the same as the last data that was previously written to that location by the computer system.
Various situations, however, can cause retrieved data to be inaccurate. One such situation involves a problem with the storage location itself (e.g., a defect in a disk that causes bad sectors and corrupts the data stored there), or with the transmittal of the data (e.g., background noise on a transmission line that results in a 0 bit being mistakenly identified as a 1 bit). Alternatively, the satisfaction (i.e., processing and performance) of read and write requests can cause inaccuracy if requests are not satisfied in the order that they are issued. It is possible for a read or write request (i.e., a data request) that is issued later than another data request to be satisfied before the earlier-issued request, referred to as the later-issued request passing the earlier-issued request. If a read request passes an earlier write request to the same location, the data retrieved in satisfaction of the read request will reflect data that had previously been stored in the location instead of the data from the write request. Similarly, if a write request passes an earlier read request, then the data retrieved in satisfaction of the read request may be the data stored by the later write request.
Generally, a situation involving later requests passing earlier requests involves a design or manufacturing flaw in a computer system. During development, some computer systems may have design flaws that allow read requests to pass write requests. For example, many computer systems have a cache memory as well as a main memory, with the cache memory added to speed up the processing by the system. Cache memories are typically smaller than the main memory, but can operate more quickly. When the computer system receives a write request to a memory location in main memory, it is possible for the computer system to instead store the data temporarily in the cache before transferring it to main memory. However, if a later read request for the memory location in main memory is satisfied before the information is transferred from the cache, then the data returned for the read request will reflect data that was previously stored in that memory location. Thus, since the write request was not fully satisfied before the later read request was satisfied, the effect was that the read request passed the write request and retrieved inaccurate data. Various techniques have been used to prevent this problem, typically requiring that earlier write requests be fully performed before the satisfaction of the later read request can begin (e.g., requiring that the cache be flushed before read requests from main memory are satisfied).
Write requests which pass earlier read requests have rarely been a problem for computer systems. While highly unusual, however, it is possible for a computer system to have a flaw which would allow this to happen. For example, if both read and write requests are queued for satisfaction until a sufficient number of requests have accumulated, it is possible that a flaw could cause the computer system to inadvertently perform requests in an order other than the order of issuance. If so, a write request could pass a read request, with the data returned for a read request corresponding to data that was stored for a later-issued write request. Alternatively, if a computer system allowed requests to be issued with different priorities, a later-issued write request with a high priority could pass an earlier-issued read that was delayed due to its low priority.
In order to identify problems with later data requests that inadvertently pass earlier ones, computer manufacturers typically test computer systems before they are shipped, and many computer systems include diagnostic tests that are periodically performed during normal operation. One method of testing a data storage location is for the computer system to issue a series of read and write requests to the location and to verify that the data returned for the read requests corresponds to the last write request issued before the read. It is common to test main memory in this manner.
Recently, however, computer systems have been designed which intentionally allow data requests to pass earlier requests. For example, some personal computer systems use an interface which allows write requests from a video subsystem of the computer to pass earlier read requests from the video subsystem. Devices which use this interface, referred to as the Accelerated Graphics Port (AGP) interface, can access video data that is stored in the main memory of the computer system without the intervention of the computer system's CPU (for a description of the AGP interface, see the Accelerated Graphics Port Interface Specification, Revision 1.0, Jul. 31, 1996 from Intel Corp. In such a system where writes can pass reads, the data retrieved in satisfaction of a read request can accurately be the data from a write request issued before or after the read request, depending on whether a later write request is actually satisfied before the read request. This behavior can be desired for a variety of reasons. For example, some computer systems may need the most recent data that is available, and thus are willing to allow later write requests to pass earlier read requests. Alternately, if the returned data is only a small part of a rapidly changing display, such as a single pixel on a computer screen that is updated multiple times per second, the overhead associated with requiring that requests be processed in order may outweigh the minor problem of having an inaccurate pixel.
Although some computer systems may allow some data requests to pass other data requests, there are typically still some ordering requirements among data requests. For example, later read requests may not be allowed to pass earlier read requests and later write requests may not be allowed to pass earlier write requests. Since it is important that the ordering requirements are followed, it is necessary to test such computer systems in the same manner that other computer systems are tested. However, the testing of computer systems that allow some data requests to pass other data requests is much more difficult than in traditional computer systems that do not allow passing of requests. In particular, there is no longer a guarantee that the data returned for a read request will correspond to the last write request issued before the read.
Thus, computer systems which allow later-issued data requests to pass earlier-issued data requests, such as systems with a device using an AGP interface to store data in memory, can no longer use conventional memory testing techniques to test the memory or to test the operation of the device. If a write can pass a read, then the result of a read when testing memory could accurately be different data. Thus, the conventional memory technique that simply compares the result of a read to the previously issued write will no longer work.